<template>
  <n-config-provider :theme="naiveTheme">
    <n-message-provider>
      <n-dialog-provider>
        <!-- 所有页面使用统一的布局 -->
        <AppLayout />
        
        <!-- 全局登录/注册遮罩组件 -->
        <AuthModal 
          :visible="authModalStore.visible" 
          @update:visible="authModalStore.hideAuthModal" 
          @login-success="handleLoginSuccess" 
        />
      </n-dialog-provider>
    </n-message-provider>
  </n-config-provider>
</template>

<script setup lang="ts">
import { onMounted, onUnmounted, computed } from 'vue'
import { createDiscreteApi } from 'naive-ui'
import { darkTheme, lightTheme } from 'naive-ui'
import AppLayout from './modules/layout/components/AppLayout.vue'
import AuthModal from './modules/auth/components/AuthModal.vue'
import { NConfigProvider, NMessageProvider, NDialogProvider } from 'naive-ui'
import { useUserStore } from './modules/auth/stores/user'
import { useModelStore } from './modules/shared/stores/model'
import { useSettingsStore } from './modules/shared/stores/settings'
import { useAuthModalStore } from './modules/auth/stores/authModal'
import { setGlobalMessageInstance } from './utils/message'
import { ErrorHandler } from './utils/error'
import { BaseService } from './modules/shared/services/base-service'
import { useAuthManager } from './modules/auth/composables/useAuthManager'

// 使用 createDiscreteApi 创建消息实例
const { message } = createDiscreteApi(['message'])

// 设置全局消息实例
setGlobalMessageInstance(message)

// 设置错误处理器的消息实例
ErrorHandler.setMessageInstance(message)
BaseService.setMessageInstance(message)

const userStore = useUserStore()
const modelStore = useModelStore()
const settingsStore = useSettingsStore()
const authModalStore = useAuthModalStore()
const { initializeAuth, isAuthenticated } = useAuthManager()

// 计算Naive UI主题
const naiveTheme = computed(() => {
  if (settingsStore.theme === 'dark') {
    return darkTheme
  } else if (settingsStore.theme === 'auto') {
    // 自动模式：根据系统偏好设置
    if (typeof window !== 'undefined') {
      const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches
      return prefersDark ? darkTheme : lightTheme
    }
    return lightTheme
  } else {
    return lightTheme
  }
})

// 监听系统主题变化
onMounted(() => {
  if (typeof window !== 'undefined') {
    const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)')
    const handleSystemThemeChange = () => {
      // 强制重新计算naiveTheme
      naiveTheme.value && naiveTheme.value
    }
    
    // 添加监听器
    mediaQuery.addEventListener('change', handleSystemThemeChange)
    
    // 组件卸载时移除监听器
    onUnmounted(() => {
      mediaQuery.removeEventListener('change', handleSystemThemeChange)
    })
  }
})

// 添加全局认证错误事件监听 - 改进版，增加防抖机制
let authErrorCount = 0
let lastAuthErrorTime = 0
const AUTH_ERROR_DEBOUNCE_TIME = 5000 // 5秒内只处理一次认证错误

const handleAuthError = () => {
  const now = Date.now()
  
  // 防抖处理：5秒内只处理一次认证错误
  if (now - lastAuthErrorTime < AUTH_ERROR_DEBOUNCE_TIME) {
    console.log(`认证错误触发过于频繁，忽略本次请求 (距离上次${now - lastAuthErrorTime}ms)`)
    return
  }
  
  authErrorCount++
  lastAuthErrorTime = now
  console.log(`检测到认证失败，第${authErrorCount}次`)
  
  // 显示登录遮罩
  authModalStore.showAuthModal()
  
  // 清除用户信息和token
  console.log('清除用户信息和token')
  userStore.setUserInfo(null)
  userStore.clearToken()
}

// 添加事件监听器
window.addEventListener('auth-error', handleAuthError)

// 组件卸载时移除事件监听器
onUnmounted(() => {
  window.removeEventListener('auth-error', handleAuthError)
})

onMounted(async () => {
  // 初始化主题
  settingsStore.initTheme()
  
  // 使用useAuthManager初始化认证状态
  await initializeAuth()
  
  // 初始化用户状态
  userStore.initUserState()
  
  // 初始化token - 确保从localStorage同步到store
  const token = localStorage.getItem('auth_token')
  if (token) {
    userStore.setToken(token)
    console.log('App.vue: 从localStorage初始化token到store')
  }
  
  const refreshToken = localStorage.getItem('refresh_token')
  if (refreshToken) {
    userStore.setRefreshToken(refreshToken)
    console.log('App.vue: 从localStorage初始化refreshToken到store')
  }
  
  // 检查开发者工具状态（仅在Electron环境中）
  if (typeof window !== 'undefined' && window.electronAPI) {
    // 延迟检查开发者工具状态，确保页面完全加载
    setTimeout(async () => {
      try {
        const electronAPI = window.electronAPI as any
        const isDevToolsOpened = await electronAPI.isDevToolsOpened()
        console.log('开发者工具状态:', isDevToolsOpened)
        
        // 如果环境变量设置了开启调试控制台但开发者工具未打开，尝试打开
        if (import.meta.env.VITE_ENABLE_DEBUG_CONSOLE === 'true' && !isDevToolsOpened) {
          console.log('尝试打开开发者工具')
          const opened = await electronAPI.openDevTools()
          if (opened) {
            console.log('开发者工具已打开')
          } else {
            console.log('开发者工具打开失败或已打开')
          }
        }
      } catch (error) {
        console.error('检查开发者工具状态失败:', error)
      }
    }, 2000) // 延迟2秒执行
  }
  
  // 修复userId类型问题 - 确保userId是数字类型
  try {
    // 检查并修复userStore中的userId类型
    if (typeof userStore.userId === 'string' && userStore.userId !== '') {
      const parsedUserId = parseInt(userStore.userId, 10)
      if (!isNaN(parsedUserId)) {
        userStore.setUserId(parsedUserId)
        console.log('App.vue: 修复userStore.userId类型:', typeof parsedUserId, parsedUserId)
      }
    }
  } catch (error) {
    console.error('修复userId类型失败:', error)
  }
  
  // 初始化模型状态
  await initModelState()
  
  // 检查是否有登录后的重定向地址
  const loginRedirect = localStorage.getItem('login_redirect')
  if (loginRedirect) {
    // 清除重定向地址
    localStorage.removeItem('login_redirect')
    
    // 延迟执行重定向，确保页面完全加载
    setTimeout(() => {
      console.log('执行登录后重定向到:', loginRedirect)
      window.location.href = loginRedirect
    }, 1000)
  }
})

// 初始化模型状态
async function initModelState() {
  try {
    // 不再在应用初始化时强制检查认证状态
    // 模型加载将在需要时进行，由后端接口处理权限验证
    console.log('应用初始化：跳过认证检查，延迟模型加载')
    return
    
    // 以下代码暂时不执行，避免在应用启动时触发登录弹窗
    /*
    // 使用useAuthManager的isAuthenticated而不是直接调用authService
    if (!isAuthenticated.value) {
      console.log('用户未登录，显示登录弹窗')
      // 使用authPromptService显示登录弹窗
      try {
        const { authPromptService } = await import('./modules/auth/services/auth-prompt-service')
        await authPromptService.showLoginPrompt()
      } catch (error) {
        console.error('显示登录弹窗失败:', error)
      }
      return
    }
    
    // 使用model store的loadModels方法加载模型列表
    await modelStore.loadModels()
    
    // 如果没有保存的模型，设置默认模型
    if (!modelStore.currentChatModel && modelStore.models.length > 0) {
      // 找到第一个对话类型的模型
      const chatModel = modelStore.models.find(model => 
        model.type === '对话'
      )
      if (chatModel) {
        modelStore.setCurrentChatModel(chatModel.id)
        modelStore.setModelByTag('对话', chatModel.id)
        if (chatModel.tags) {
          modelStore.setCurrentModelTags(chatModel.tags)
        }
      } else {
        // 如果没有找到对话类型的模型，使用第一个模型
        const firstModel = modelStore.models[0]
        modelStore.setCurrentChatModel(firstModel.id)
        modelStore.setModelByTag('对话', firstModel.id)
        if (firstModel.tags) {
          modelStore.setCurrentModelTags(firstModel.tags)
        }
      }
    } else if (modelStore.currentChatModel) {
      // 如果有保存的模型，验证它是否仍然存在
      const savedModel = modelStore.getModelById(modelStore.currentChatModel)
      if (savedModel && savedModel.tags) {
        modelStore.setCurrentModelTags(savedModel.tags)
      } else if (!savedModel && modelStore.models.length > 0) {
        // 如果保存的模型不存在，找到第一个对话类型的模型
        const chatModel = modelStore.models.find(model => 
          model.type === '对话' || (model.tags && model.tags.includes('chat'))
        )
        if (chatModel) {
          modelStore.setCurrentChatModel(chatModel.id)
          modelStore.setModelByTag('对话', chatModel.id)
          if (chatModel.tags) {
            modelStore.setCurrentModelTags(chatModel.tags)
          }
        } else {
          // 如果没有找到对话类型的模型，使用第一个模型
          const firstModel = modelStore.models[0]
          modelStore.setCurrentChatModel(firstModel.id)
          modelStore.setModelByTag('对话', firstModel.id)
          if (firstModel.tags) {
            modelStore.setCurrentModelTags(firstModel.tags)
          }
        }
      }
    }
    */
  } catch (error) {
    console.error('初始化模型状态失败:', error)
  }
}

// 处理登录成功事件
async function handleLoginSuccess() {
  console.log('用户登录成功，初始化用户数据')
  
  try {
    // 确保token已同步到localStorage和全局请求头
    const token = userStore.token
    if (token) {
      localStorage.setItem('auth_token', token)
      console.log('handleLoginSuccess: 已同步token到localStorage')
      
      // 确保请求拦截器能获取到最新的token
      const { ApiConfig } = await import('./modules/shared/services/api-config')
      await ApiConfig.setToken(token)
      console.log('handleLoginSuccess: 已设置token到ApiConfig')
    }
    
    // 初始化模型状态
    await initModelState()
    
    // 延迟初始化WebSocket服务，确保认证状态完全稳定
    setTimeout(async () => {
      try {
        const { webSocketService } = await import('./modules/shared/services/websocket-service')
        
        // 再次检查用户认证状态
        if (userStore.isAuthenticated && userStore.getToken()) {
          console.log('用户认证状态有效，尝试连接WebSocket')
          await webSocketService.connect()
          console.log('WebSocket连接成功')
        } else {
          console.log('用户认证状态无效，跳过WebSocket连接')
        }
      } catch (error) {
        console.error('WebSocket连接失败:', error)
        // WebSocket连接失败不影响其他功能
      }
    }, 2000) // 延迟2秒连接，确保认证状态完全稳定
    
    // 不再在登录后初始化会话，因为用户不一定直接进入聊天页面
    // 会话初始化将在用户访问聊天页面时进行
    console.log('登录成功，会话初始化将在访问聊天页面时进行')
  } catch (error) {
    console.error('登录后初始化数据失败:', error)
  }
}
</script>